/*
C++ 类 & 对象
*/
#include <iostream>
using namespace std;

class Box
{
	public :
	double length;
	double breadth;
	double height;
}

int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}

//C++ 继承

#include <iostream>
using namespace std;

//基类
class Shape{
	public:
		void setWidth(int w)
		{
			width = w;
		}
		void setHeight(int h)
		{
			height = h;
		}
	protected:
	int width;
	int height;	
}
//派生类
class Rectanle: public Shape
{
	public:
		int getArea()
		{
			return (width*height);
		}
}

int main(void)
{
	Rectanle Rect;
	Rect.setWidth(5);
	Rect.setHeight(7);
	cout <<"Total area" << Rect.getArea() << endl;
	return 0;
}

//多继承
class Rectangel: public Shape,public PainCost
{

}
//C++ 重载运算符和重载函数
/*
C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
*/
//C++ 中的函数重载
/*
在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。

下面的实例中，同名函数 print() 被用于输出不同的数据类型：
*/

#include <iostream>
using namespace std;
 
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
 
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
 
   return 0;
}
///C++ 多态
/*
多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。
C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
*/
#include <iossteam>
using namespace std;

class Shape
{
	protected:
		int width,height;
	public:
		shape(int a=0, int b=0)
		{
			width = a;
			height = b;	
		}
		virtual int area()
		{
			cout << "Parent class area:" << endl;
			return 0;
		}
}
class Rectangle: public shape
{
	public:
		Rectangle(int a=0, int b=0):Shape(a, b){}
	int area()
	{
		cout << "Rectangle class area :" <<endl;
        return (width * height); 
	}
}
class Triangle: public Shape
{
	public:
		Triangle(int a=0, int b=0):Shape(a,b){}
	int area()
	{
		cout << "Triangle class area :" <<endl;
        return (width * height / 2); 
	}
}
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

//C++ 数据抽象